Zeiger in Go sind ein leistungsstarkes Tool zum Verwalten des Speichers und zum Bearbeiten von Daten. Sie bieten eine Möglichkeit, direkt auf die Speicheradresse einer Variablen zu verweisen und ermöglichen so einen effizienten Zugriff und eine effiziente Bearbeitung von Datenstrukturen.
Was ist ein Zeiger?
In Go ist ein Zeiger eine Variable, die die Adresse einer anderen Variablen speichert. Die Adresse ist der eindeutige Speicherort, an dem die Variable gespeichert ist. Zeiger werden mit dem Operator „&“ erstellt, der die Adresse einer Variablen zurückgibt.
Nehmen wir zum Beispiel an, wir haben eine Variable „number“ vom Typ „int“. Mit dem Operator „&“ können wir einen Zeiger auf „Nummer“ erstellen:
„Geh
Zahl :=10
Zeiger :=&Nummer
„
Die Variable „pointer“ speichert nun die Speicheradresse der Variablen „number“.
Dereferenzieren eines Zeigers
Um auf den Wert eines Zeigers zuzugreifen, können wir den Operator „*“ verwenden. Der „*“-Operator dereferenziert einen Zeiger und gibt den Wert zurück, der an der Speicheradresse gespeichert ist, die der Zeiger enthält.
In unserem Beispiel können wir die Variable „pointer“ dereferenzieren, um auf den Wert der Variablen „number“ zuzugreifen:
„Geh
dereferenzierteNummer :=*Zeiger
„
Die Variable „deferencedNumber“ speichert jetzt den Wert der Variablen „number“, also 10.
Zeigerarithmetik
Zeiger können auch zur Zeigerarithmetik verwendet werden. Bei der Zeigerarithmetik werden ganze Zahlen zu einem Zeiger addiert oder subtrahiert, um die Speicheradresse zu ändern, auf die er verweist.
Nehmen wir zum Beispiel an, wir haben ein Array von Ganzzahlen namens „arr“ und möchten die Elemente des Arrays durchlaufen. Wir können den Operator „+“ verwenden, um eine Ganzzahl zu einem Zeiger hinzuzufügen, um zum nächsten Element des Arrays zu gelangen:
„Geh
arr :=[5]int{1, 2, 3, 4, 5}
// Initialisiere einen Zeiger auf das erste Element des Arrays
Zeiger :=&arr[0]
// Mit Zeigerarithmetik durch das Array iterieren
für i :=0; i
// Den Zeiger dereferenzieren, um den Wert am aktuellen Index zu erhalten
Wert :=*Zeiger
// Den Wert drucken
fmt.Println(Wert)
// Den Zeiger erhöhen, um zum nächsten Element des Arrays zu gelangen
Zeiger++
}
„
In diesem Beispiel wird der Zeiger „pointer“ zunächst auf die Adresse des ersten Elements des Arrays gesetzt. Dann durchläuft die „for“-Schleife das Array und dereferenziert den „Zeiger“ bei jeder Iteration, um den Wert des aktuellen Elements zu erhalten. Der „Zeiger“ wird dann inkrementiert, um zum nächsten Element des Arrays zu gelangen.
Zeiger an Funktionen übergeben
Zeiger können als Argumente an Funktionen übergeben werden. Dadurch können Funktionen die Speicheradresse von Variablen direkt manipulieren, anstatt eine Kopie der Variablen zu erstellen.
Nehmen wir zum Beispiel an, wir haben eine Funktion namens „Inkrement“, die den Wert einer Ganzzahl erhöht. Wir können einen Zeiger auf eine Ganzzahl als Argument an die Funktion „Inkrement“ übergeben, sodass die Funktion den Wert der Ganzzahl direkt ändern kann:
„Geh
func inkrement(ptr *int) {
// Den Zeiger dereferenzieren, um den Wert an der Speicheradresse zu erhalten
Wert :=*ptr
// Den Wert erhöhen
Wert++
// Den inkrementierten Wert wieder an der Speicheradresse speichern
*ptr =Wert
}
func main() {
// Erstelle eine Integer-Variable
Zahl :=10
// Einen Zeiger auf die Variable als Argument an die Inkrementfunktion übergeben
Inkrement(&Anzahl)
// Den inkrementierten Wert ausgeben
fmt.Println(number) // Ausgabe:11
}
„
In diesem Beispiel verwendet die Funktion „Inkrement“ einen Zeiger auf eine Ganzzahl als Argument. Die Funktion dereferenziert den Zeiger, um den Wert an der Speicheradresse abzurufen, erhöht den Wert,
